<html>
<head><meta charset="utf-8"><title>super traits are not considered for const evaluatable bounds · project-const-generics · Zulip Chat Archive</title></head>
<h2>Stream: <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/index.html">project-const-generics</a></h2>
<h3>Topic: <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html">super traits are not considered for const evaluatable bounds</a></h3>

<hr>

<base href="https://rust-lang.zulipchat.com">

<head><link href="https://rust-lang.github.io/zulip_archive/style.css" rel="stylesheet"></head>

<a name="225984529"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225984529" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225984529">(Feb 11 2021 at 12:47)</a>:</h4>
<p>In the following snippet, the trait declaration of <code>MyTrait</code> will complain about <code>K + 1</code> </p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">trait</span><span class="w"> </span><span class="n">PhantomConstU64</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">U</span>: <span class="kt">u64</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>

<span class="k">trait</span><span class="w"> </span><span class="n">MyTrait</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">K</span>: <span class="kt">u64</span><span class="o">&gt;</span>: <span class="nc">PhantomConstU64</span><span class="o">&lt;</span><span class="p">{</span><span class="n">K</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">}</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>
<p>Now, this makes sense, after all, the (I think?) equivalent type code is</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">trait</span><span class="w"> </span><span class="n">PhantomConstU64</span><span class="o">&lt;</span><span class="n">U</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>

<span class="k">struct</span> <span class="nc">SomeStruct</span><span class="o">&lt;</span><span class="n">T</span>: <span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Debug</span><span class="o">&gt;</span><span class="p">(</span><span class="n">T</span><span class="p">);</span><span class="w"></span>

<span class="k">trait</span><span class="w"> </span><span class="n">MyTrait</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;</span>: <span class="nc">PhantomConstU64</span><span class="o">&lt;</span><span class="n">SomeStruct</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;&gt;&gt;</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>
<p>which fails to compile because <code>K</code> does not have a <code>Debug</code> bound, which is easy to add. But <code>where</code> bounds require any users to prove <code>{K + 1}</code> (or <code>Debug</code>) with their own where bounds instead of just having <code>MyTrait</code> automatically prove and require <code>{K + 1}</code></p>
<p>So... getting back to my original issue, I want to unify multiple const generic bounds in a single named thing so during bubbling I don't have to re-specify it at every level</p>



<a name="225985218"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985218" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985218">(Feb 11 2021 at 12:54)</a>:</h4>
<p>so the solution here is to add a const evaluatable bound for <code>K + 1</code> to <code>MyTrait</code>?</p>



<a name="225985229"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985229" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985229">(Feb 11 2021 at 12:54)</a>:</h4>
<p>am i understanding you correctly here?</p>



<a name="225985277"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985277" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985277">(Feb 11 2021 at 12:55)</a>:</h4>
<p>well... that is not a solution, as that is equivalent to adding a <code>where [(); K + 1]: ,</code> bound, and will still require you to specify it whenever you use <code>MyTrait</code></p>



<a name="225985298"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985298" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985298">(Feb 11 2021 at 12:55)</a>:</h4>
<p>I'm not sure going via traits is the solution here at all</p>



<a name="225985315"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985315" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985315">(Feb 11 2021 at 12:55)</a>:</h4>
<p>but if it were, we'd also need to change it for types</p>



<a name="225985341"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985341" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985341">(Feb 11 2021 at 12:56)</a>:</h4>
<p>don't want to allow something that isn't allowed by typenum already without heavily involving T-lang</p>



<a name="225985444"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985444" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985444">(Feb 11 2021 at 12:56)</a>:</h4>
<p>then I am a bit confused</p>



<a name="225985496"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985496" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985496">(Feb 11 2021 at 12:57)</a>:</h4>
<p>ok.. let me start from the beginning</p>



<a name="225985762"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225985762" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225985762">(Feb 11 2021 at 13:00)</a>:</h4>
<p>I have <code>fn foo&lt;const K: usize&gt;() where [(); K + 1]: , [(); K - 1]: , { ... code goes here ...}</code>. But since everything calling <code>foo</code> needs to prove <code>K + 1</code> and <code>K - 1</code> I need to keep adding those bounds in every caller to <code>foo</code>. What I want is to have a single bound that says <code>K + 1</code> works and <code>K - 1</code> works. Ideally a "named" bound. Traits seemed like the obvious go-to candidate for these, but I couldn't tell how to do that properly, but maybe associated consts are the solution?</p>



<a name="225986293"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225986293" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225986293">(Feb 11 2021 at 13:05)</a>:</h4>
<p>i expect this to work:</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="cp">#![feature(const_evaluatable_checked, const_generics)]</span><span class="w"></span>

<span class="k">struct</span> <span class="nc">C</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>

<span class="k">trait</span><span class="w"> </span><span class="n">Foo</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">K</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">C</span><span class="o">&lt;</span><span class="p">{</span><span class="w"> </span><span class="n">K</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">}</span><span class="o">&gt;</span>: <span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="n">C</span><span class="o">&lt;</span><span class="p">{</span><span class="w"> </span><span class="n">K</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">}</span><span class="o">&gt;</span>: <span class="p">,</span><span class="w"></span>
<span class="p">{}</span><span class="w"></span>

<span class="k">impl</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">K</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Foo</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">C</span><span class="o">&lt;</span><span class="p">{</span><span class="w"> </span><span class="n">K</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">}</span><span class="o">&gt;</span>: <span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="n">C</span><span class="o">&lt;</span><span class="p">{</span><span class="w"> </span><span class="n">K</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="w"> </span><span class="p">}</span><span class="o">&gt;</span>: <span class="p">,</span><span class="w"></span>
<span class="p">{}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">foo</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="p">()</span>: <span class="nc">Foo</span><span class="o">&lt;</span><span class="n">N</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">_</span>: <span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">];</span><span class="w"></span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">_</span>: <span class="p">[</span><span class="kt">u8</span><span class="p">;</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">];</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="225986312"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225986312" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225986312">(Feb 11 2021 at 13:05)</a>:</h4>
<p>i think i know why it doesn't work rn</p>



<a name="225986594"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225986594" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225986594">(Feb 11 2021 at 13:08)</a>:</h4>
<p>my initial thought was wrong</p>



<a name="225987051"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225987051" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225987051">(Feb 11 2021 at 13:12)</a>:</h4>
<p>ok, so i need to look a bit into the difference between <code>super_predicates_of</code> and <code>predicates_of</code></p>



<a name="225987078"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225987078" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225987078">(Feb 11 2021 at 13:12)</a>:</h4>
<p>and expect that we want to add <code>ConstEvaluatable</code> predicates to <code>super_predicates_of</code> as well</p>



<a name="225987108"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225987108" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225987108">(Feb 11 2021 at 13:13)</a>:</h4>
<p>at which point my example should work</p>



<a name="225987841"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225987841" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225987841">(Feb 11 2021 at 13:18)</a>:</h4>
<p>well... The following example with types instead of const generics also fails. Again, I think that it's equivalent, but I may be misinterpreting things.</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">struct</span> <span class="nc">C</span><span class="o">&lt;</span><span class="n">N</span><span class="o">&gt;</span><span class="p">;</span><span class="w"></span>

<span class="k">trait</span><span class="w"> </span><span class="n">Foo</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">K</span>: <span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Debug</span><span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="n">K</span>: <span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Display</span><span class="p">,</span><span class="w"></span>
<span class="p">{}</span><span class="w"></span>

<span class="k">impl</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Foo</span><span class="o">&lt;</span><span class="n">K</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
<span class="k">where</span><span class="w"></span>
<span class="w">    </span><span class="n">K</span>: <span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Debug</span><span class="p">,</span><span class="w"></span>
<span class="w">    </span><span class="n">K</span>: <span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Display</span><span class="p">,</span><span class="w"></span>
<span class="p">{}</span><span class="w"></span>

<span class="k">fn</span> <span class="nf">foo</span><span class="o">&lt;</span><span class="n">N</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="k">where</span><span class="w"> </span><span class="p">()</span>: <span class="nc">Foo</span><span class="o">&lt;</span><span class="n">N</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">x</span>: <span class="nc">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="fm">unimplemented!</span><span class="p">();</span><span class="w"></span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">y</span>: <span class="kp">&amp;</span><span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Debug</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&amp;</span><span class="n">x</span><span class="p">;</span><span class="w"> </span><span class="c1">// `N: Debug` is not satisfied</span>
<span class="w">    </span><span class="kd">let</span><span class="w"> </span><span class="n">z</span>: <span class="kp">&amp;</span><span class="nc">std</span>::<span class="n">fmt</span>::<span class="n">Display</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">&amp;</span><span class="n">x</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
</code></pre></div>



<a name="225987947"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225987947" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225987947">(Feb 11 2021 at 13:19)</a>:</h4>
<p>So... I'm not sure why this is not done in the type based example, but if there's a reason for it, then the equivalent thing in const generics may be unsound</p>



<a name="225988338"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225988338" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225988338">(Feb 11 2021 at 13:22)</a>:</h4>
<p>if/when we add const-evaluatable-checked requirements for associated constants, we could make <a href="https://play.rust-lang.org/?version=nightly&amp;mode=debug&amp;edition=2018&amp;gist=7e5446814741baee6d8ce168cbace6cd">https://play.rust-lang.org/?version=nightly&amp;mode=debug&amp;edition=2018&amp;gist=7e5446814741baee6d8ce168cbace6cd</a> work</p>



<a name="225988346"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225988346" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225988346">(Feb 11 2021 at 13:22)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds/near/225987947">said</a>:</p>
<blockquote>
<p>So... I'm not sure why this is not done in the type based example, but if there's a reason for it, then the equivalent thing in const generics may be unsound</p>
</blockquote>
<p>neither do i <span aria-label="sweat smile" class="emoji emoji-1f605" role="img" title="sweat smile">:sweat_smile:</span> i always thought this works</p>



<a name="225988449"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225988449" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225988449">(Feb 11 2021 at 13:23)</a>:</h4>
<p>does it only elaborate supertraits?</p>



<a name="225988484"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225988484" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225988484">(Feb 11 2021 at 13:23)</a>:</h4>
<p>yea</p>



<a name="225988659"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225988659" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225988659">(Feb 11 2021 at 13:24)</a>:</h4>
<p>if we could do <code>trait Foo&lt;const K: usize&gt;: {K + 1}</code> or something weird like that, then everything would fall in place (at least the way my brain is currently interpreting things)</p>



<a name="225990521"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225990521" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225990521">(Feb 11 2021 at 13:38)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds/near/225987947">said</a>:</p>
<blockquote>
<p>So... I'm not sure why this is not done in the type based example, but if there's a reason for it, then the equivalent thing in const generics may be unsound</p>
</blockquote>
<p>afaict this was done to prevent cycle errors, not because it would be unsound</p>



<a name="225990621"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225990621" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225990621">(Feb 11 2021 at 13:39)</a>:</h4>
<p>but it is unfortunate because being able to elaborate const evaluatable bounds seems really desirable to me</p>



<a name="225994491"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994491" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994491">(Feb 11 2021 at 14:04)</a>:</h4>
<p>well, what I think is entirely uncontroversial is to walk the super predicates to find all const evaluatable bounds</p>



<a name="225994622"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994622" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994622">(Feb 11 2021 at 14:05)</a>:</h4>
<p>but exposing them in a way that just having the trait bound will also put these const evaluatable bounds in scope requires some more thought</p>



<a name="225994653"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994653" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994653">(Feb 11 2021 at 14:05)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds/near/225994491">said</a>:</p>
<blockquote>
<p>well, what I think is entirely uncontroversial is to walk the super predicates to find all const evaluatable bounds</p>
</blockquote>
<p>that means we want like</p>
<div class="codehilite" data-code-language="Rust"><pre><span></span><code><span class="k">trait</span><span class="w"> </span><span class="n">ConstEvaluatable</span><span class="o">&lt;</span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
<span class="k">impl</span><span class="o">&lt;</span><span class="n">T</span>: <span class="o">?</span><span class="nb">Sized</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">N</span>: <span class="kt">usize</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ConstEvaluatable</span><span class="o">&lt;</span><span class="n">N</span><span class="o">&gt;</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="p">{}</span><span class="w"></span>
</code></pre></div>



<a name="225994667"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994667" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994667">(Feb 11 2021 at 14:06)</a>:</h4>
<p>i think</p>



<a name="225994776"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994776" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994776">(Feb 11 2021 at 14:06)</a>:</h4>
<p>at least for now</p>



<a name="225994890"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225994890" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225994890">(Feb 11 2021 at 14:07)</a>:</h4>
<blockquote>
<p>that means we want like</p>
</blockquote>
<p>uh, more words please. Not sure what you're trying to tell me with that code snippet</p>



<a name="225995073"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995073" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995073">(Feb 11 2021 at 14:08)</a>:</h4>
<p>to have const evaluatable bounds in the super traits</p>



<a name="225995086"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995086" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995086">(Feb 11 2021 at 14:08)</a>:</h4>
<p>we need a trait with a const param</p>



<a name="225995107"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995107" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995107">(Feb 11 2021 at 14:08)</a>:</h4>
<p>ah, yes</p>



<a name="225995124"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995124" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995124">(Feb 11 2021 at 14:09)</a>:</h4>
<p>which is kinda annoying ^^</p>



<a name="225995155"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995155" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995155">(Feb 11 2021 at 14:09)</a>:</h4>
<p>it is ^^</p>



<a name="225995351"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995351" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995351">(Feb 11 2021 at 14:10)</a>:</h4>
<p>I have needed <code>struct ConstU64&lt;const U: U64&gt;;</code> quite a few times already, but never considered the trait equivalent. We have a similar issue for lifetimes on <code>impl Trait</code> return types</p>



<a name="225995399"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995399" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995399">(Feb 11 2021 at 14:10)</a>:</h4>
<p>where just adding another trait with lifetime bounds can fix some problems</p>



<a name="225995413"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995413" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995413">(Feb 11 2021 at 14:10)</a>:</h4>
<p><code>trait Captures&lt;'a&gt;</code></p>



<a name="225995419"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995419" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995419">(Feb 11 2021 at 14:10)</a>:</h4>
<p>that one</p>



<a name="225995574"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995574" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995574">(Feb 11 2021 at 14:11)</a>:</h4>
<p>So adding one for const evaluatable makes sense, but having <code>ConstEvaluatable&lt;{K + 1}&gt;</code> everywhere is quite a mouth full</p>



<a name="225995654"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995654" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995654">(Feb 11 2021 at 14:12)</a>:</h4>
<p>yeah, also we need a new one for every possible type</p>



<a name="225995658"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995658" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995658">(Feb 11 2021 at 14:12)</a>:</h4>
<p>also we can't really make it generic over the const type (due to the structural-match problem)</p>



<a name="225995664"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995664" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995664">(Feb 11 2021 at 14:12)</a>:</h4>
<p>haha yea that</p>



<a name="225995672"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995672" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995672">(Feb 11 2021 at 14:12)</a>:</h4>
<p>^^</p>



<a name="225995700"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995700" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995700">(Feb 11 2021 at 14:12)</a>:</h4>
<p>unless we quickly go ahead and work on generic const param types</p>



<a name="225995726"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995726" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> Boxy [she/her] <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995726">(Feb 11 2021 at 14:12)</a>:</h4>
<p><code>struct ConstNum&lt;T, const N: T&gt;</code><br>
one day<span aria-label="tm" class="emoji emoji-2122" role="img" title="tm">:tm:</span></p>



<a name="225995819"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995819" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995819">(Feb 11 2021 at 14:13)</a>:</h4>
<p>I won't promise anything, but that sounds like a reasonable project for me to do next month. <em>puts it on the maybe-do list</em></p>



<a name="225995934"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995934" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995934">(Feb 11 2021 at 14:14)</a>:</h4>
<p><span class="user-mention silent" data-user-id="124288">oli</span> <a href="#narrow/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds/near/225995819">said</a>:</p>
<blockquote>
<p>I won't promise anything, but that sounds like a reasonable project for me to do next month. <em>puts it on the maybe-do list</em></p>
</blockquote>
<p>generic param types?</p>



<a name="225995947"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995947" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995947">(Feb 11 2021 at 14:14)</a>:</h4>
<p>yea</p>



<a name="225995985"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995985" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995985">(Feb 11 2021 at 14:14)</a>:</h4>
<p>well. lots and lots of structural-match refactorings to be more precise</p>



<a name="225995992"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225995992" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225995992">(Feb 11 2021 at 14:14)</a>:</h4>
<p>-&gt; <a href="https://github.com/rust-lang/project-const-generics/pull/3">https://github.com/rust-lang/project-const-generics/pull/3</a></p>



<a name="225996052"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225996052" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225996052">(Feb 11 2021 at 14:15)</a>:</h4>
<p>did you already look at <code>WithOptConstParam</code> before?</p>



<a name="225996094"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225996094" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> oli <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225996094">(Feb 11 2021 at 14:15)</a>:</h4>
<p>Oh, I don't care about the design <span aria-label="grinning" class="emoji emoji-1f600" role="img" title="grinning">:grinning:</span> I want to finish value trees so all of this is not built on top of a card house</p>



<a name="225996140"></a>
<h4><a href="https://rust-lang.zulipchat.com#narrow/stream/260443-project-const-generics/topic/super%20traits%20are%20not%20considered%20for%20const%20evaluatable%20bounds/near/225996140" class="zl"><img src="https://rust-lang.github.io/zulip_archive/assets/img/zulip.svg" alt="view this post on Zulip" style="width:20px;height:20px;"></a> lcnr <a href="https://rust-lang.github.io/zulip_archive/stream/260443-project-const-generics/topic/super.20traits.20are.20not.20considered.20for.20const.20evaluatable.20bounds.html#225996140">(Feb 11 2021 at 14:15)</a>:</h4>
<p>yeah, val trees will be great <span aria-label="heart" class="emoji emoji-2764" role="img" title="heart">:heart:</span></p>



<hr><p>Last updated: Aug 07 2021 at 22:04 UTC</p>
</html>